﻿package core.image
{
    import __AS3__.vec.*;
    import flash.display.*;
    import flash.filters.*;
    import flash.geom.*;

    public class Filter extends Object
    {

        public function Filter()
        {
            return;
        }// end function

        private function sqr(core.image:Filter:int) : int
        {
            return core.image:Filter * core.image:Filter;
        }// end function

        public function clamp(core.image:Filter:int, core.image:Filter:int, core.image:Filter:int) : int
        {
            return core.image:Filter < core.image:Filter ? (core.image:Filter) : (core.image:Filter > core.image:Filter ? (core.image:Filter) : (core.image:Filter));
        }// end function

        public function ColorLookup(_local8:BitmapData, _local8:BitmapData, _local8:BitmapData, _local8:Selection, _local8:Point) : void
        {
            var _loc_6:int = 0;
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            var _loc_9:uint = 0;
            var _loc_10:int = 0;
            var _loc_11:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            var _loc_12:* = _loc_11.top;
            while (_loc_12 < _loc_11.bottom)
            {
                
                _loc_10 = _loc_11.left;
                while (_loc_10 < _loc_11.right)
                {
                    
                    _loc_9 = _local8.getPixel(_loc_10, _loc_12);
                    _loc_6 = _loc_9 >>> 16 & 255;
                    _loc_7 = _loc_9 >>> 8 & 255;
                    _loc_8 = _loc_9 & 255;
                    _local8.setPixel(_loc_10, _loc_12, _local8.getPixel(int((_loc_6 + _loc_7 + _loc_8) / 3), 0));
                    _loc_10++;
                }
                _loc_12++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        private function MixColors(_local11:Number, _local11:uint, _local11:uint) : uint
        {
            var _loc_4:* = _local11 >> 24 & 255;
            var _loc_5:* = _local11 >> 16 & 255;
            var _loc_6:* = _local11 >> 8 & 255;
            var _loc_7:* = _local11 & 255;
            var _loc_8:* = _local11 >> 24 & 255;
            var _loc_9:* = _local11 >> 16 & 255;
            var _loc_10:* = _local11 >> 8 & 255;
            var _loc_11:* = _local11 & 255;
            _loc_4 = _loc_4 + _local11 * (_loc_8 - _loc_4);
            _loc_5 = _loc_5 + _local11 * (_loc_9 - _loc_5);
            _loc_6 = _loc_7 + _local11 * (_loc_11 - _loc_7);
            _loc_7 = _loc_7 + _local11 * (_loc_10 - _loc_6);
            return _loc_4 << 24 | _loc_5 << 16 | _loc_6 << 8 | _loc_7;
        }// end function

        public function TriTone(_local8:BitmapData, _local8:BitmapData, _local8:uint, _local8:uint, _local8:uint, _local8:Selection, _local8:Point) : void
        {
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_12:uint = 0;
            var _loc_13:Number = NaN;
            var _loc_14:int = 0;
            var _loc_15:* = new Vector.<int>(256, true);
            _loc_8 = 0;
            while (_loc_8 < 128)
            {
                
                _loc_13 = _loc_8 / 127;
                _loc_15[_loc_8] = this.MixColors(_loc_13, _local8, _local8);
                _loc_8++;
            }
            _loc_8 = 128;
            while (_loc_8 < 256)
            {
                
                _loc_13 = (_loc_8 - 127) / 128;
                _loc_15[_loc_8] = this.MixColors(_loc_13, _local8, _local8);
                _loc_8++;
            }
            var _loc_16:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            var _loc_17:* = _loc_16.top;
            while (_loc_17 < _loc_16.bottom)
            {
                
                _loc_14 = _loc_16.left;
                while (_loc_14 < _loc_16.right)
                {
                    
                    _loc_12 = _local8.getPixel(_loc_14, _loc_17);
                    _loc_9 = _loc_12 >>> 16 & 255;
                    _loc_10 = _loc_12 >>> 8 & 255;
                    _loc_11 = _loc_12 & 255;
                    _local8.setPixel(_loc_14, _loc_17, _loc_15[Math.round((_loc_9 + _loc_10 + _loc_11) / 3)]);
                    _loc_14++;
                }
                _loc_17++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function AutoLevels(_local8:BitmapData, _local8:BitmapData, _local8:Selection, _local8:Point) : void
        {
            var _loc_5:int = 0;
            var _loc_6:int = 0;
            var _loc_7:int = 0;
            var _loc_8:uint = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_12:int = 0;
            var _loc_11:* = new Vector.<int>(256, true);
            while (_loc_12 < _local8.width)
            {
                
                _loc_10 = 0;
                while (_loc_10 < _local8.height)
                {
                    
                    _loc_8 = _local8.getPixel32(_loc_12, _loc_10);
                    if ((_loc_8 >>> 24 & 255) > 0)
                    {
                        _loc_5 = _loc_8 >>> 16 & 255;
                        _loc_6 = _loc_8 >>> 8 & 255;
                        _loc_7 = _loc_8 & 255;
                        (_loc_11[_loc_5] + 1);
                        (_loc_11[_loc_6] + 1);
                        (_loc_11[_loc_7] + 1);
                    }
                    _loc_10++;
                }
                _loc_12++;
            }
            var _loc_13:* = Math.round(_local8.width * _local8.height / 1000);
            var _loc_14:* = new ChannelMap();
            _loc_9 = 0;
            while (_loc_9 < 256)
            {
                
                if (_loc_11[_loc_9] > _loc_13)
                {
                    _loc_14.minin = _loc_9;
                    break;
                }
                _loc_9++;
            }
            _loc_9 = 255;
            while (_loc_9 >= 0)
            {
                
                if (_loc_11[_loc_9] > _loc_13)
                {
                    _loc_14.maxin = _loc_9;
                    break;
                }
                _loc_9 = _loc_9 - 1;
            }
            _local8.paletteMap(_local8, _local8.rect, _local8.rect.topLeft, _loc_14.ComputeArray(16), _loc_14.ComputeArray(8), _loc_14.ComputeArray(0));
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Pointinize(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:Selection, _local8:Point) : void
        {
            var _loc_6:Vector.<int> = null;
            var _loc_7:uint = 0;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_12:int = 0;
            var _loc_13:int = 0;
            switch(_local8)
            {
                case 0:
                {
                    _loc_6 = this.Vector.<int>([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]);
                    break;
                }
                case 1:
                {
                    _loc_6 = this.Vector.<int>([0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0]);
                    break;
                }
                case 2:
                {
                    _loc_6 = this.Vector.<int>([0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0]);
                    break;
                }
                case 3:
                {
                    _loc_6 = this.Vector.<int>([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
                    break;
                }
                default:
                {
                    break;
                }
            }
            var _loc_14:* = Math.sqrt(_loc_6.length);
            var _loc_15:* = int(_loc_14 / 2);
            _local8.lock();
            var _loc_16:* = _loc_15;
            while (_loc_16 < _local8.height)
            {
                
                _loc_11 = _loc_15;
                while (_loc_11 < _local8.width)
                {
                    
                    _loc_7 = _local8.getPixel(_loc_11, _loc_16);
                    _loc_12 = -_loc_15;
                    while (_loc_12 < _loc_14 - _loc_15)
                    {
                        
                        _loc_13 = -_loc_15;
                        while (_loc_13 < _loc_14 - _loc_15)
                        {
                            
                            _local8.setPixel(_loc_11 + _loc_13, _loc_16 + _loc_12, _loc_6[(_loc_12 + _loc_15) * _loc_14 + _loc_13 + _loc_15] == 0 ? (0) : (_loc_7));
                            _loc_13++;
                        }
                        _loc_12++;
                    }
                    _loc_11 = _loc_11 + _loc_14;
                }
                _loc_16 = _loc_16 + _loc_14;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function TiltShift(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:int, _local8:Boolean) : void
        {
            var _loc_6:ColorMatrix = null;
            _local8.applyFilter(_local8, _local8.rect, _local8.rect.topLeft, new BlurFilter(5, 5, 3));
            var _loc_7:* = new Sprite();
            var _loc_8:* = new Matrix();
            _loc_8.createGradientBox(_local8.width, _local8.height * (_local8 / 100), 90 / (180 / Math.PI), 0, _local8.height * ((_local8 - _local8) / 100));
            _loc_7.graphics.beginGradientFill("linear", new Array(16777215, 16777215, 16777215, 16777215), new Array(0, 1, 1, 0), new Array(0, 94, 162, 255), _loc_8);
            _loc_7.graphics.drawRect(0, 0, _local8.width, _local8.height);
            var _loc_9:* = new BitmapData(_local8.width, _local8.height, true, 16777215);
            _loc_9.draw(_loc_7);
            _local8.copyPixels(_local8, _local8.rect, _local8.rect.topLeft, _loc_9, _loc_9.rect.topLeft, true);
            if (_local8)
            {
                _loc_6 = new ColorMatrix();
                _loc_6.AdjustSaturation(1.5);
                _local8.applyFilter(_local8, _local8.rect, _local8.rect.topLeft, _loc_6.filter);
            }
            return;
        }// end function

        public function Heatmap(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:Selection, _local8:Point) : void
        {
            var _loc_6:int = 0;
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:uint = 0;
            var _loc_11:int = 0;
            var _loc_12:* = (100 - _local8) * 512 / 100 * (2 / 3);
            var _loc_13:* = (100 - _local8) * 512 / 100 / 3;
            var _loc_14:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            var _loc_15:* = _loc_14.top;
            while (_loc_15 < _loc_14.bottom)
            {
                
                _loc_11 = _loc_14.left;
                while (_loc_11 < _loc_14.right)
                {
                    
                    _loc_10 = _local8.getPixel(_loc_11, _loc_15);
                    _loc_6 = _loc_10 >>> 16 & 255;
                    _loc_7 = _loc_10 >>> 8 & 255;
                    _loc_8 = _loc_10 & 255;
                    _loc_9 = (_loc_6 + _loc_7 + _loc_8) / 3;
                    if (_loc_9 < _loc_13)
                    {
                        _loc_6 = 0;
                        _loc_7 = 0;
                        _loc_7 = _loc_9 / _loc_12 * 255;
                    }
                    else if (_loc_9 >= _loc_13 && _loc_9 < _loc_12)
                    {
                        _loc_6 = 0;
                        _loc_7 = (_loc_9 - _loc_13) / _loc_13 * 255;
                        _loc_8 = 0;
                    }
                    else
                    {
                        _loc_6 = 255;
                        _loc_7 = 255 - (_loc_9 - _loc_12) / _loc_13 * 255;
                        _loc_8 = 0;
                    }
                    if (_loc_6 > 255)
                    {
                        _loc_6 = 255;
                    }
                    else if (_loc_6 < 0)
                    {
                        _loc_6 = 0;
                    }
                    if (_loc_7 > 255)
                    {
                        _loc_7 = 255;
                    }
                    else if (_loc_7 < 0)
                    {
                        _loc_7 = 0;
                    }
                    if (_loc_8 > 255)
                    {
                        _loc_8 = 255;
                    }
                    else if (_loc_8 < 0)
                    {
                        _loc_8 = 0;
                    }
                    _loc_10 = (_loc_10 & 4278190080) + (_loc_6 << 16) + (_loc_7 << 8) + _loc_8;
                    _local8.setPixel(_loc_11, _loc_15, _loc_10);
                    _loc_11++;
                }
                _loc_15++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Vignette(_local8:BitmapData, _local8:uint = 0, _local8:int = 50) : void
        {
            var _loc_4:int = 0;
            var _loc_5:int = 0;
            var _loc_6:int = 0;
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_12:uint = 0;
            var _loc_13:Number = NaN;
            var _loc_14:Number = NaN;
            var _loc_15:Number = NaN;
            var _loc_16:int = 0;
            var _loc_21:int = 0;
            var _loc_17:* = _local8.width / 2;
            var _loc_18:* = _local8.height / 2;
            var _loc_19:* = _loc_17 - _local8 * (_loc_17 / 3) / 100;
            var _loc_20:* = _loc_18 - _local8 * (_loc_18 / 3) / 100;
            _loc_7 = _local8 >>> 16 & 255;
            _loc_8 = _local8 >>> 8 & 255;
            _loc_9 = _local8 & 255;
            _local8.lock();
            while (_loc_21 < _local8.width)
            {
                
                _loc_16 = 0;
                while (_loc_16 < _local8.height)
                {
                    
                    _loc_12 = _local8.getPixel(_loc_21, _loc_16);
                    _loc_4 = _loc_12 >>> 16 & 255;
                    _loc_5 = _loc_12 >>> 8 & 255;
                    _loc_6 = _loc_12 & 255;
                    _loc_10 = _loc_17 - _loc_21;
                    _loc_11 = _loc_18 - _loc_16;
                    _loc_15 = _loc_10 * _loc_10 / (_loc_19 * _loc_19) + _loc_11 * _loc_11 / (_loc_20 * _loc_20);
                    if (_loc_15 > 1)
                    {
                        _loc_13 = (_loc_15 - 1) / 1.5;
                        _loc_14 = 1 - _loc_13;
                        _loc_4 = _loc_14 * _loc_4 + _loc_13 * _loc_7;
                        _loc_5 = _loc_14 * _loc_5 + _loc_13 * _loc_8;
                        _loc_6 = _loc_14 * _loc_6 + _loc_13 * _loc_9;
                        if (_loc_4 > 255)
                        {
                            _loc_4 = 255;
                        }
                        else if (_loc_4 < 0)
                        {
                            _loc_4 = 0;
                        }
                        if (_loc_5 > 255)
                        {
                            _loc_5 = 255;
                        }
                        else if (_loc_5 < 0)
                        {
                            _loc_5 = 0;
                        }
                        if (_loc_6 > 255)
                        {
                            _loc_6 = 255;
                        }
                        else if (_loc_6 < 0)
                        {
                            _loc_6 = 0;
                        }
                        _local8.setPixel(_loc_21, _loc_16, _loc_4 << 16 | _loc_5 << 8 | _loc_6);
                    }
                    _loc_16++;
                }
                _loc_21++;
            }
            _local8.unlock();
            return;
        }// end function

        public function Hope(_local8:BitmapData, _local8:BitmapData, _local8:Selection, _local8:Point) : void
        {
            var _loc_5:int = 0;
            var _loc_6:int = 0;
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            var _loc_9:uint = 0;
            var _loc_10:int = 0;
            var _loc_11:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            var _loc_12:* = _loc_11.top;
            while (_loc_12 < _loc_11.bottom)
            {
                
                _loc_10 = _loc_11.left;
                while (_loc_10 < _loc_11.right)
                {
                    
                    _loc_9 = _local8.getPixel(_loc_10, _loc_12);
                    _loc_5 = _loc_9 >>> 16 & 255;
                    _loc_6 = _loc_9 >>> 8 & 255;
                    _loc_7 = _loc_9 & 255;
                    _loc_8 = (_loc_5 + _loc_6 + _loc_7) / 3;
                    if (_loc_8 < 64)
                    {
                        _local8.setPixel(_loc_10, _loc_12, 12877);
                    }
                    else if (_loc_8 < 128)
                    {
                        _local8.setPixel(_loc_10, _loc_12, 14031393);
                    }
                    else if (_loc_8 < 172)
                    {
                        _local8.setPixel(_loc_10, _loc_12, 7378334);
                    }
                    else
                    {
                        _local8.setPixel(_loc_10, _loc_12, 16507815);
                    }
                    _loc_10++;
                }
                _loc_12++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function CrossProcess(_local8:BitmapData, _local8:BitmapData, _local8:Selection, _local8:Point) : void
        {
            var _loc_5:* = new Array(0, 0, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 9, 9, 9, 9, 9, 9, 11, 11, 11, 12, 12, 12, 14, 14, 14, 15, 15, 15, 17, 17, 17, 18, 18, 18, 20, 20, 21, 21, 21, 23, 23, 23, 24, 26, 26, 27, 29, 29, 30, 32, 32, 33, 35, 35, 36, 38, 38, 39, 41, 41, 42, 44, 44, 45, 48, 48, 50, 53, 53, 54, 56, 56, 59, 62, 62, 63, 65, 65, 66, 71, 71, 72, 74, 74, 78, 78, 78, 83, 84, 84, 87, 90, 90, 92, 96, 96, 98, 101, 101, 104, 105, 105, 108, 111, 111, 116, 117, 117, 120, 123, 123, 125, 129, 129, 131, 132, 132, 137, 138, 138, 143, 146, 146, 147, 152, 152, 153, 155, 155, 159, 162, 162, 164, 168, 168, 170, 173, 173, 176, 179, 179, 182, 183, 183, 186, 189, 189, 191, 192, 192, 195, 197, 197, 201, 203, 203, 206, 206, 206, 209, 212, 212, 215, 216, 216, 218, 219, 219, 222, 225, 225, 227, 228, 228, 231, 233, 233, 234, 236, 236, 237, 240, 240, 242, 245, 245, 248, 249, 249, 249, 251, 251, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254);
            var _loc_6:* = new Array(0, 2, 3, 3, 5, 6, 6, 8, 9, 9, 9, 11, 11, 12, 14, 14, 15, 17, 17, 17, 18, 18, 20, 21, 21, 23, 24, 24, 24, 26, 26, 27, 29, 29, 30, 32, 32, 33, 35, 35, 36, 38, 38, 41, 41, 41, 42, 44, 44, 45, 47, 47, 50, 50, 50, 51, 53, 53, 54, 56, 56, 59, 60, 60, 62, 63, 63, 66, 68, 68, 69, 71, 71, 72, 74, 74, 75, 78, 78, 80, 83, 83, 84, 86, 86, 89, 90, 90, 92, 95, 95, 96, 98, 98, 101, 102, 102, 105, 107, 107, 108, 110, 110, 113, 116, 116, 117, 119, 119, 122, 123, 123, 125, 128, 128, 129, 132, 132, 134, 137, 137, 138, 140, 140, 141, 144, 144, 146, 149, 149, 150, 153, 153, 155, 156, 156, 159, 161, 161, 162, 165, 165, 167, 168, 168, 171, 173, 173, 174, 176, 176, 179, 180, 180, 182, 185, 185, 186, 188, 188, 189, 191, 191, 192, 194, 194, 195, 198, 198, 200, 201, 201, 203, 204, 204, 206, 207, 207, 209, 210, 210, 212, 213, 213, 215, 215, 215, 216, 218, 218, 219, 221, 221, 222, 224, 224, 224, 225, 225, 227, 227, 227, 228, 230, 230, 230, 231, 231, 233, 233, 233, 234, 234, 234, 236, 236, 236, 237, 237, 237, 239, 239, 239, 240, 240, 240, 242, 243, 243, 243, 243, 243, 245, 245, 245, 246, 246, 246, 248, 248, 248, 249, 249, 249, 249, 251, 251, 251, 252, 252, 252, 252, 252, 254, 254, 254);
            var _loc_7:* = new Array(23, 24, 26, 26, 27, 29, 29, 30, 32, 32, 32, 33, 33, 35, 36, 36, 36, 38, 38, 39, 41, 41, 41, 44, 44, 45, 47, 47, 47, 48, 48, 50, 51, 51, 51, 53, 53, 54, 56, 56, 57, 59, 59, 60, 62, 62, 62, 63, 63, 65, 66, 66, 66, 68, 68, 69, 71, 71, 72, 74, 74, 75, 75, 75, 77, 78, 78, 80, 81, 81, 81, 83, 83, 84, 86, 86, 87, 87, 87, 89, 90, 90, 92, 93, 93, 95, 96, 96, 98, 99, 99, 99, 101, 101, 102, 104, 104, 105, 105, 105, 107, 108, 108, 110, 110, 110, 111, 113, 113, 114, 116, 116, 117, 119, 119, 119, 120, 120, 122, 123, 123, 125, 125, 125, 126, 128, 128, 129, 131, 131, 132, 134, 134, 134, 135, 135, 137, 138, 138, 140, 141, 141, 143, 143, 143, 144, 146, 146, 147, 149, 149, 149, 150, 150, 152, 153, 153, 153, 155, 155, 156, 158, 158, 159, 161, 161, 162, 162, 162, 164, 165, 165, 167, 168, 168, 170, 171, 171, 171, 173, 173, 174, 176, 176, 177, 177, 177, 179, 180, 180, 182, 183, 183, 185, 186, 186, 186, 188, 188, 189, 191, 191, 191, 192, 192, 194, 195, 195, 197, 198, 198, 200, 201, 201, 203, 203, 203, 204, 206, 206, 207, 207, 207, 209, 210, 210, 212, 213, 213, 215, 216, 216, 218, 218, 218, 219, 221, 221, 222, 222, 222, 224, 225, 225, 227, 228, 228, 230, 230, 230, 231, 233, 233, 234, 236, 236);
            _local8.paletteMap(_local8, _local8.rect, _local8.rect.topLeft, Misc.ComputePaletteArray(_loc_5, 16), Misc.ComputePaletteArray(_loc_6, 8), Misc.ComputePaletteArray(_loc_7, 0));
            var _loc_8:* = new ColorMatrix();
            _loc_8.AdjustContrast(0.1);
            _local8.applyFilter(_local8, _local8.rect, _local8.rect.topLeft, _loc_8.filter);
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Solarize(_local8:BitmapData, _local8:BitmapData, _local8:Selection, _local8:Point) : void
        {
            var _loc_5:int = 0;
            var _loc_6:int = 0;
            var _loc_7:* = new Array(256);
            _loc_5 = 0;
            while (_loc_5 < 256)
            {
                
                _loc_6 = 255 * (_loc_5 / 255 > 0.5 ? (2 * (_loc_5 / 255 - 0.5)) : (2 * (0.5 - _loc_5 / 255)));
                _loc_7[_loc_5] = _loc_6 > 255 ? (255) : (_loc_6 < 0 ? (0) : (_loc_6 << 16));
                _loc_5++;
            }
            var _loc_8:* = new Array(256);
            _loc_5 = 0;
            while (_loc_5 < 256)
            {
                
                _loc_6 = 255 * (_loc_5 / 255 > 0.5 ? (2 * (_loc_5 / 255 - 0.5)) : (2 * (0.5 - _loc_5 / 255)));
                _loc_8[_loc_5] = _loc_6 > 255 ? (255) : (_loc_6 < 0 ? (0) : (_loc_6 << 8));
                _loc_5++;
            }
            var _loc_9:* = new Array(256);
            _loc_5 = 0;
            while (_loc_5 < 256)
            {
                
                _loc_6 = 255 * (_loc_5 / 255 > 0.5 ? (2 * (_loc_5 / 255 - 0.5)) : (2 * (0.5 - _loc_5 / 255)));
                _loc_9[_loc_5] = _loc_6 > 255 ? (255) : (_loc_6 < 0 ? (0) : (_loc_6 << 0));
                _loc_5++;
            }
            _local8.paletteMap(_local8, _local8.rect, _local8.rect.topLeft, _loc_7, _loc_8, _loc_9);
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Exposure(_local8:BitmapData, _local8:BitmapData, _local8:Number, _local8:Selection, _local8:Point) : void
        {
            var _loc_6:int = 0;
            var _loc_7:int = 0;
            var _loc_8:* = new Array(256);
            _loc_6 = 0;
            while (_loc_6 < 256)
            {
                
                _loc_7 = 255 - Math.exp((-_loc_6) / 255 * _local8) * 255;
                _loc_8[_loc_6] = _loc_7 > 255 ? (255) : (_loc_7 < 0 ? (0) : (_loc_7 << 16));
                _loc_6++;
            }
            var _loc_9:* = new Array(256);
            _loc_6 = 0;
            while (_loc_6 < 256)
            {
                
                _loc_7 = 255 - Math.exp((-_loc_6) / 255 * _local8) * 255;
                _loc_9[_loc_6] = _loc_7 > 255 ? (255) : (_loc_7 < 0 ? (0) : (_loc_7 << 8));
                _loc_6++;
            }
            var _loc_10:* = new Array(256);
            _loc_6 = 0;
            while (_loc_6 < 256)
            {
                
                _loc_7 = 255 - Math.exp((-_loc_6) / 255 * _local8) * 255;
                _loc_10[_loc_6] = _loc_7 > 255 ? (255) : (_loc_7 < 0 ? (0) : (_loc_7 << 0));
                _loc_6++;
            }
            _local8.paletteMap(_local8, _local8.rect, _local8.rect.topLeft, _loc_8, _loc_9, _loc_10);
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function MimicHDR(_local8:BitmapData, _local8:BitmapData, _local8:Selection, _local8:Point) : void
        {
            var _loc_5:ColorMatrix = null;
            var _loc_6:BitmapData = null;
            var _loc_7:BitmapData = null;
            var _loc_8:BitmapData = null;
            var _loc_9:* = 1;
            _loc_6 = _local8.clone();
            _loc_8 = _local8.clone();
            _loc_5 = new ColorMatrix();
            _loc_5.Invert();
            _loc_8.applyFilter(_loc_8, _loc_8.rect, _loc_8.rect.topLeft, _loc_5.filter);
            _loc_8.applyFilter(_loc_8, _loc_8.rect, _loc_8.rect.topLeft, new BlurFilter(5, 5, 3));
            var _loc_10:* = new Bitmap(_loc_8);
            _loc_10.alpha = 0.5;
            var _loc_11:* = new Sprite();
            _loc_11.addChild(_loc_10);
            _loc_6.draw(_loc_11);
            var _loc_12:* = new ChannelMap();
            _loc_12.minin = 85;
            _loc_12.maxin = 170;
            _loc_6.paletteMap(_loc_6, _loc_6.rect, _loc_6.rect.topLeft, _loc_12.ComputeArray(16), _loc_12.ComputeArray(8), _loc_12.ComputeArray(0));
            _loc_7 = _local8.clone();
            _loc_5 = new ColorMatrix();
            _loc_5.Invert();
            _loc_5.Desaturate();
            _loc_7.applyFilter(_loc_7, _loc_7.rect, _loc_7.rect.topLeft, _loc_5.filter);
            _loc_7.applyFilter(_loc_7, _loc_7.rect, _loc_7.rect.topLeft, new BlurFilter(50, 50, 10));
            var _loc_13:* = new Bitmap(_loc_7);
            _loc_13.blendMode = "overlay";
            var _loc_14:* = new Sprite();
            _loc_14.addChild(_loc_13);
            _local8.draw(_loc_14);
            var _loc_15:* = new Bitmap(_loc_6);
            _loc_15.blendMode = "overlay";
            var _loc_16:* = new Sprite();
            _loc_16.addChild(_loc_15);
            _local8.draw(_loc_16);
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function GlamourGlow(_local8:BitmapData, _local8:BitmapData, _local8:Selection, _local8:Point) : void
        {
            var _loc_5:* = _local8.clone();
            var _loc_6:* = new ColorMatrix();
            _loc_6.Desaturate();
            _loc_5.applyFilter(_loc_5, _loc_5.rect, _loc_5.rect.topLeft, _loc_6.filter);
            _loc_5.applyFilter(_loc_5, _loc_5.rect, _loc_5.rect.topLeft, new BlurFilter(10, 10, 10));
            var _loc_7:* = new Bitmap(_loc_5);
            _loc_7.blendMode = "hardlight";
            var _loc_8:* = new Sprite();
            _loc_8.addChild(_loc_7);
            _local8.draw(_loc_8);
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Denoise(_local8:BitmapData, _local8:BitmapData, _local8:Selection, _local8:Point) : void
        {
            var _loc_5:uint = 0;
            var _loc_6:uint = 0;
            var _loc_7:uint = 0;
            var _loc_8:uint = 0;
            var _loc_9:uint = 0;
            var _loc_10:int = 0;
            var _loc_11:* = new Array(5);
            var _loc_12:* = new Array(5);
            var _loc_13:* = new Array(5);
            var _loc_14:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            if (_loc_14.left == 0)
            {
                var _loc_16:* = _loc_14;
                var _loc_17:* = _loc_14.left + 1;
                _loc_16.left = _loc_17;
            }
            if (_loc_14.top == 0)
            {
                var _loc_16:* = _loc_14;
                var _loc_17:* = _loc_14.top + 1;
                _loc_16.top = _loc_17;
            }
            if (_loc_14.right == _local8.width)
            {
                var _loc_16:* = _loc_14;
                var _loc_17:* = _loc_14.right - 1;
                _loc_16.right = _loc_17;
            }
            if (_loc_14.bottom == _local8.height)
            {
                var _loc_16:* = _loc_14;
                var _loc_17:* = _loc_14.bottom - 1;
                _loc_16.bottom = _loc_17;
            }
            _local8.lock();
            var _loc_15:* = _loc_14.top;
            while (_loc_15 < _loc_14.bottom)
            {
                
                _loc_7 = _local8.getPixel(1, _loc_15);
                _loc_6 = _local8.getPixel(0, _loc_15);
                _loc_10 = _loc_14.left;
                while (_loc_10 < _loc_14.right)
                {
                    
                    _loc_5 = _loc_6;
                    _loc_6 = _loc_7;
                    _loc_8 = _local8.getPixel(_loc_10, (_loc_15 + 1));
                    _loc_9 = _local8.getPixel(_loc_10, (_loc_15 - 1));
                    _loc_7 = _local8.getPixel((_loc_10 + 1), _loc_15);
                    _loc_11[0] = _loc_5 >>> 16 & 255;
                    _loc_11[1] = _loc_7 >>> 16 & 255;
                    _loc_11[2] = _loc_6 >>> 16 & 255;
                    _loc_11[3] = _loc_8 >>> 16 & 255;
                    _loc_11[4] = _loc_9 >>> 16 & 255;
                    _loc_12[0] = _loc_5 >>> 8 & 255;
                    _loc_12[1] = _loc_7 >>> 8 & 255;
                    _loc_12[2] = _loc_6 >>> 8 & 255;
                    _loc_12[3] = _loc_8 >>> 8 & 255;
                    _loc_12[4] = _loc_9 >>> 8 & 255;
                    _loc_13[0] = _loc_5 & 255;
                    _loc_13[1] = _loc_7 & 255;
                    _loc_13[2] = _loc_6 & 255;
                    _loc_13[3] = _loc_8 & 255;
                    _loc_13[4] = _loc_9 & 255;
                    _local8.setPixel(_loc_10, _loc_15, _loc_11.sort(16)[2] << 16 | _loc_12.sort(16)[2] << 8 | _loc_13.sort(16)[2]);
                    _loc_10++;
                }
                _loc_15++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Posterize(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:Selection, _local8:Point) : void
        {
            var _loc_6:Number = NaN;
            var _loc_7:uint = 0;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_12:* = Math.ceil(255 / (_local8 - 1));
            var _loc_13:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            var _loc_14:* = _loc_13.top;
            while (_loc_14 < _loc_13.bottom)
            {
                
                _loc_11 = _loc_13.left;
                while (_loc_11 < _loc_13.right)
                {
                    
                    _loc_7 = _local8.getPixel(_loc_11, _loc_14);
                    _loc_8 = _loc_7 >>> 16 & 255;
                    _loc_9 = _loc_7 >>> 8 & 255;
                    _loc_10 = _loc_7 & 255;
                    _loc_6 = _loc_8 / _loc_12;
                    if (_loc_6 > _local8 - 1.75)
                    {
                        _loc_6 = Math.ceil(_loc_6);
                    }
                    if (_loc_6 < 0.75)
                    {
                        _loc_6 = Math.floor(_loc_6);
                    }
                    _loc_8 = Math.round(_loc_6 * _loc_12);
                    _loc_6 = _loc_9 / _loc_12;
                    if (_loc_6 > _local8 - 1.75)
                    {
                        _loc_6 = Math.ceil(_loc_6);
                    }
                    if (_loc_6 < 0.75)
                    {
                        _loc_6 = Math.floor(_loc_6);
                    }
                    _loc_9 = Math.round(_loc_6 * _loc_12);
                    _loc_6 = _loc_10 / _loc_12;
                    if (_loc_6 > _local8 - 1.75)
                    {
                        _loc_6 = Math.ceil(_loc_6);
                    }
                    if (_loc_6 < 0.75)
                    {
                        _loc_6 = Math.floor(_loc_6);
                    }
                    _loc_10 = Math.round(_loc_6 * _loc_12);
                    if (_loc_8 > 255)
                    {
                        _loc_8 = 255;
                    }
                    else if (_loc_8 < 0)
                    {
                        _loc_8 = 0;
                    }
                    if (_loc_9 > 255)
                    {
                        _loc_9 = 255;
                    }
                    else if (_loc_9 < 0)
                    {
                        _loc_9 = 0;
                    }
                    if (_loc_10 > 255)
                    {
                        _loc_10 = 255;
                    }
                    else if (_loc_10 < 0)
                    {
                        _loc_10 = 0;
                    }
                    _local8.setPixel(_loc_11, _loc_14, _loc_8 << 16 | _loc_9 << 8 | _loc_10);
                    _loc_11++;
                }
                _loc_14++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Sepia(_local8:BitmapData, _local8:BitmapData, _local8:Selection, _local8:Point) : void
        {
            var _loc_5:uint = 0;
            var _loc_6:int = 0;
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            var _loc_12:* = _loc_11.top;
            while (_loc_12 < _loc_11.bottom)
            {
                
                _loc_10 = _loc_11.left;
                while (_loc_10 < _loc_11.right)
                {
                    
                    _loc_5 = _local8.getPixel(_loc_10, _loc_12);
                    _loc_7 = _loc_5 >>> 16 & 255;
                    _loc_8 = _loc_5 >>> 8 & 255;
                    _loc_9 = _loc_5 & 255;
                    _loc_6 = 0.299 * _loc_7 + 0.587 * _loc_8 + 0.114 * _loc_9;
                    _loc_7 = _loc_6 > 206 ? (255) : (_loc_6 + 49);
                    _loc_8 = _loc_6 < 14 ? (0) : (_loc_6 - 14);
                    _loc_9 = _loc_6 < 56 ? (0) : (_loc_6 - 56);
                    _local8.setPixel(_loc_10, _loc_12, _loc_7 << 16 | _loc_8 << 8 | _loc_9);
                    _loc_10++;
                }
                _loc_12++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function OldPhoto(_local8:BitmapData, _local8:BitmapData, _local8:Selection, _local8:Point) : void
        {
            var _loc_5:uint = 0;
            var _loc_6:int = 0;
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            var _loc_12:* = _loc_11.top;
            while (_loc_12 < _loc_11.bottom)
            {
                
                _loc_10 = _loc_11.left;
                while (_loc_10 < _loc_11.right)
                {
                    
                    _loc_5 = _local8.getPixel(_loc_10, _loc_12);
                    _loc_7 = _loc_5 >>> 16 & 255;
                    _loc_8 = _loc_5 >>> 8 & 255;
                    _loc_9 = _loc_5 & 255;
                    _loc_7 = _loc_7 * 0.393 + _loc_8 * 0.769 + _loc_9 * 0.189;
                    _loc_8 = _loc_7 * 0.349 + _loc_8 * 0.686 + _loc_9 * 0.168;
                    _loc_9 = _loc_7 * 0.272 + _loc_8 * 0.534 + _loc_9 * 0.131;
                    if (_loc_7 > 255)
                    {
                        _loc_7 = 255;
                    }
                    else if (_loc_7 < 0)
                    {
                        _loc_7 = 0;
                    }
                    if (_loc_8 > 255)
                    {
                        _loc_8 = 255;
                    }
                    else if (_loc_8 < 0)
                    {
                        _loc_8 = 0;
                    }
                    if (_loc_9 > 255)
                    {
                        _loc_9 = 255;
                    }
                    else if (_loc_9 < 0)
                    {
                        _loc_9 = 0;
                    }
                    _local8.setPixel(_loc_10, _loc_12, _loc_7 << 16 | _loc_8 << 8 | _loc_9);
                    _loc_10++;
                }
                _loc_12++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function LuminanceNoise(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:Selection, _local8:Point) : void
        {
            var _loc_6:int = 0;
            var _loc_7:uint = 0;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_12:int = 0;
            var _loc_13:* = _local8 / 2;
            var _loc_14:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            var _loc_15:* = _loc_14.top;
            while (_loc_15 < _loc_14.bottom)
            {
                
                _loc_12 = _loc_14.left;
                while (_loc_12 < _loc_14.right)
                {
                    
                    _loc_7 = _local8.getPixel(_loc_12, _loc_15);
                    _loc_9 = _loc_7 >>> 16 & 255;
                    _loc_10 = _loc_7 >>> 8 & 255;
                    _loc_11 = _loc_7 & 255;
                    _loc_6 = Math.round(Math.random() * _local8 - _loc_13);
                    _loc_9 = _loc_9 + _loc_6;
                    _loc_10 = _loc_10 + _loc_6;
                    _loc_11 = _loc_11 + _loc_6;
                    if (_loc_9 > 255)
                    {
                        _loc_9 = 255;
                    }
                    else if (_loc_9 < 0)
                    {
                        _loc_9 = 0;
                    }
                    if (_loc_10 > 255)
                    {
                        _loc_10 = 255;
                    }
                    else if (_loc_10 < 0)
                    {
                        _loc_10 = 0;
                    }
                    if (_loc_11 > 255)
                    {
                        _loc_11 = 255;
                    }
                    else if (_loc_11 < 0)
                    {
                        _loc_11 = 0;
                    }
                    _local8.setPixel(_loc_12, _loc_15, _loc_9 << 16 | _loc_10 << 8 | _loc_11);
                    _loc_12++;
                }
                _loc_15++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function ColorNoise(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:Selection, _local8:Point) : void
        {
            var _loc_6:uint = 0;
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_12:* = _local8 / 2;
            var _loc_13:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            var _loc_14:* = _loc_13.top;
            while (_loc_14 < _loc_13.bottom)
            {
                
                _loc_11 = _loc_13.left;
                while (_loc_11 < _loc_13.right)
                {
                    
                    _loc_6 = _local8.getPixel(_loc_11, _loc_14);
                    _loc_8 = _loc_6 >>> 16 & 255;
                    _loc_9 = _loc_6 >>> 8 & 255;
                    _loc_10 = _loc_6 & 255;
                    _loc_8 = _loc_8 + Math.round(Math.random() * _local8 - _loc_12);
                    _loc_9 = _loc_9 + Math.round(Math.random() * _local8 - _loc_12);
                    _loc_10 = _loc_10 + Math.round(Math.random() * _local8 - _loc_12);
                    if (_loc_8 > 255)
                    {
                        _loc_8 = 255;
                    }
                    else if (_loc_8 < 0)
                    {
                        _loc_8 = 0;
                    }
                    if (_loc_9 > 255)
                    {
                        _loc_9 = 255;
                    }
                    else if (_loc_9 < 0)
                    {
                        _loc_9 = 0;
                    }
                    if (_loc_10 > 255)
                    {
                        _loc_10 = 255;
                    }
                    else if (_loc_10 < 0)
                    {
                        _loc_10 = 0;
                    }
                    _local8.setPixel(_loc_11, _loc_14, _loc_8 << 16 | _loc_9 << 8 | _loc_10);
                    _loc_11++;
                }
                _loc_14++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Diffuse(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:Selection, _local8:Point) : void
        {
            var _loc_6:int = 0;
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            var _loc_9:* = _local8 / 2;
            var _loc_10:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            var _loc_11:* = _loc_10.top;
            while (_loc_11 < _loc_10.bottom)
            {
                
                _loc_8 = _loc_10.left;
                while (_loc_8 < _loc_10.right)
                {
                    
                    _loc_6 = _loc_8 + Math.round(Math.random() * _local8 - _loc_9);
                    _loc_7 = _loc_11 + Math.round(Math.random() * _local8 - _loc_9);
                    if (_loc_6 != _loc_8 || _loc_7 != _loc_11)
                    {
                        _local8.setPixel32(_loc_6, _loc_7, _local8.getPixel32(_loc_8, _loc_11));
                    }
                    _loc_8++;
                }
                _loc_11++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Scanlines(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:Boolean, _local8:Selection, _local8:Point) : void
        {
            var _loc_7:uint = 0;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_12:int = 0;
            var _loc_13:int = 0;
            var _loc_14:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            if (_local8)
            {
                _loc_13 = _loc_14.top;
                while (_loc_13 < _loc_14.bottom)
                {
                    
                    _loc_11 = _loc_13 % 2 == 0 ? (_local8) : (-_local8);
                    _loc_12 = _loc_14.left;
                    while (_loc_12 < _loc_14.right)
                    {
                        
                        _loc_7 = _local8.getPixel(_loc_12, _loc_13);
                        _loc_8 = _loc_7 >>> 16 & 255;
                        _loc_9 = _loc_7 >>> 8 & 255;
                        _loc_10 = _loc_7 & 255;
                        _loc_8 = _loc_8 + _loc_11;
                        _loc_9 = _loc_9 + _loc_11;
                        _loc_10 = _loc_10 + _loc_11;
                        if (_loc_8 > 255)
                        {
                            _loc_8 = 255;
                        }
                        else if (_loc_8 < 0)
                        {
                            _loc_8 = 0;
                        }
                        if (_loc_9 > 255)
                        {
                            _loc_9 = 255;
                        }
                        else if (_loc_9 < 0)
                        {
                            _loc_9 = 0;
                        }
                        if (_loc_10 > 255)
                        {
                            _loc_10 = 255;
                        }
                        else if (_loc_10 < 0)
                        {
                            _loc_10 = 0;
                        }
                        _local8.setPixel(_loc_12, _loc_13, _loc_8 << 16 | _loc_9 << 8 | _loc_10);
                        _loc_12++;
                    }
                    _loc_13++;
                }
            }
            else
            {
                _loc_12 = _loc_14.left;
                while (_loc_12 < _loc_14.right)
                {
                    
                    _loc_11 = _loc_12 % 2 == 0 ? (_local8) : (-_local8);
                    _loc_13 = _loc_14.top;
                    while (_loc_13 < _loc_14.bottom)
                    {
                        
                        _loc_7 = _local8.getPixel(_loc_12, _loc_13);
                        _loc_8 = _loc_7 >>> 16 & 255;
                        _loc_9 = _loc_7 >>> 8 & 255;
                        _loc_10 = _loc_7 & 255;
                        _loc_8 = _loc_8 + _loc_11;
                        _loc_9 = _loc_9 + _loc_11;
                        _loc_10 = _loc_10 + _loc_11;
                        if (_loc_8 > 255)
                        {
                            _loc_8 = 255;
                        }
                        else if (_loc_8 < 0)
                        {
                            _loc_8 = 0;
                        }
                        if (_loc_9 > 255)
                        {
                            _loc_9 = 255;
                        }
                        else if (_loc_9 < 0)
                        {
                            _loc_9 = 0;
                        }
                        if (_loc_10 > 255)
                        {
                            _loc_10 = 255;
                        }
                        else if (_loc_10 < 0)
                        {
                            _loc_10 = 0;
                        }
                        _local8.setPixel(_loc_12, _loc_13, _loc_8 << 16 | _loc_9 << 8 | _loc_10);
                        _loc_13++;
                    }
                    _loc_12++;
                }
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function PolarCoordinates(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:Selection, _local8:Point) : void
        {
            var _loc_6:Number = NaN;
            var _loc_7:Number = NaN;
            var _loc_8:Number = NaN;
            var _loc_9:Number = NaN;
            var _loc_10:Number = NaN;
            var _loc_11:Number = NaN;
            var _loc_12:int = 0;
            var _loc_13:int = 0;
            var _loc_14:int = 0;
            var _loc_15:int = 0;
            var _loc_16:int = 0;
            var _loc_17:int = 0;
            var _loc_22:int = 0;
            var _loc_18:* = _local8.width / 2;
            var _loc_19:* = _local8.height / 2;
            var _loc_20:* = Math.max(_loc_19, _loc_18);
            var _loc_21:Number = 0;
            while (_loc_22 < _local8.height)
            {
                
                _loc_17 = 0;
                while (_loc_17 < _local8.width)
                {
                    
                    switch(_local8)
                    {
                        case 0:
                        {
                            _loc_9 = 0;
                            if (_loc_17 >= _loc_18)
                            {
                                if (_loc_22 > _loc_19)
                                {
                                    _loc_9 = Math.PI - Math.atan((_loc_17 - _loc_18) / (_loc_22 - _loc_19));
                                    _loc_21 = Math.sqrt(this.sqr(_loc_17 - _loc_18) + this.sqr(_loc_22 - _loc_19));
                                }
                                else if (_loc_22 < _loc_19)
                                {
                                    _loc_9 = Math.atan((_loc_17 - _loc_18) / (_loc_19 - _loc_22));
                                    _loc_21 = Math.sqrt(this.sqr(_loc_17 - _loc_18) + this.sqr(_loc_19 - _loc_22));
                                }
                                else
                                {
                                    _loc_9 = Math.PI / 2;
                                    _loc_21 = _loc_17 - _loc_18;
                                }
                            }
                            else if (_loc_17 < _loc_18)
                            {
                                if (_loc_22 < _loc_19)
                                {
                                    _loc_9 = Math.PI * 2 - Math.atan((_loc_18 - _loc_17) / (_loc_19 - _loc_22));
                                    _loc_21 = Math.sqrt(this.sqr(_loc_18 - _loc_17) + this.sqr(_loc_19 - _loc_22));
                                }
                                else if (_loc_22 > _loc_19)
                                {
                                    _loc_9 = Math.PI + Math.atan((_loc_18 - _loc_17) / (_loc_22 - _loc_19));
                                    _loc_21 = Math.sqrt(this.sqr(_loc_18 - _loc_17) + this.sqr(_loc_22 - _loc_19));
                                }
                                else
                                {
                                    _loc_9 = 1.5 * Math.PI;
                                    _loc_21 = _loc_18 - _loc_17;
                                }
                            }
                            if (_loc_17 != _loc_18)
                            {
                                _loc_6 = Math.abs((_loc_22 - _loc_19) / (_loc_17 - _loc_18));
                            }
                            else
                            {
                                _loc_6 = 0;
                            }
                            if (_loc_6 <= _local8.height / _local8.width)
                            {
                                if (_loc_17 == _loc_18)
                                {
                                    _loc_7 = 0;
                                    _loc_8 = _loc_19;
                                }
                                else
                                {
                                    _loc_7 = _loc_18;
                                    _loc_8 = _loc_6 * _loc_7;
                                }
                            }
                            else
                            {
                                _loc_8 = _loc_19;
                                _loc_7 = _loc_8 / _loc_6;
                            }
                            _loc_12 = (_local8.width - 1) - (_local8.width - 1) / (Math.PI * 2) * _loc_9;
                            _loc_13 = _local8.height * _loc_21 / _loc_20;
                            break;
                        }
                        case 1:
                        {
                            _loc_9 = _loc_17 / _local8.width * (Math.PI * 2);
                            if (_loc_9 >= 1.5 * Math.PI)
                            {
                                _loc_10 = Math.PI * 2 - _loc_9;
                            }
                            else if (_loc_9 >= Math.PI)
                            {
                                _loc_10 = _loc_9 - Math.PI;
                            }
                            else if (_loc_9 >= 0.5 * Math.PI)
                            {
                                _loc_10 = Math.PI - _loc_9;
                            }
                            else
                            {
                                _loc_10 = _loc_9;
                            }
                            _loc_11 = Math.tan(_loc_10);
                            if (_loc_11 != 0)
                            {
                                _loc_6 = 1 / _loc_11;
                            }
                            else
                            {
                                _loc_6 = 0;
                            }
                            if (_loc_6 <= _local8.height / _local8.width)
                            {
                                if (_loc_10 == 0)
                                {
                                    _loc_7 = 0;
                                    _loc_8 = _loc_19;
                                }
                                else
                                {
                                    _loc_7 = _loc_18;
                                    _loc_8 = _loc_6 * _loc_7;
                                }
                            }
                            else
                            {
                                _loc_8 = _loc_19;
                                _loc_7 = _loc_8 / _loc_6;
                            }
                            _loc_21 = _loc_20 * (_loc_22 / _local8.height);
                            _loc_12 = (-_loc_21) * Math.sin(_loc_10);
                            _loc_13 = _loc_21 * Math.cos(_loc_10);
                            if (_loc_9 >= 1.5 * Math.PI)
                            {
                                _loc_12 = _loc_18 - _loc_12;
                                _loc_13 = _loc_19 - _loc_13;
                            }
                            else if (_loc_9 >= Math.PI)
                            {
                                _loc_12 = _loc_18 - _loc_12;
                                _loc_13 = _loc_19 + _loc_13;
                            }
                            else if (_loc_9 >= 0.5 * Math.PI)
                            {
                                _loc_12 = _loc_18 + _loc_12;
                                _loc_13 = _loc_19 + _loc_13;
                            }
                            else
                            {
                                _loc_12 = _loc_18 + _loc_12;
                                _loc_13 = _loc_19 - _loc_13;
                            }
                            break;
                        }
                        case 2:
                        {
                            _loc_14 = _loc_17 - _loc_18;
                            _loc_15 = _loc_22 - _loc_19;
                            _loc_16 = _loc_14 * _loc_14 + _loc_15 * _loc_15;
                            _loc_12 = _loc_18 + _loc_18 * _loc_18 * _loc_14 / _loc_16;
                            _loc_13 = _loc_19 + _loc_19 * _loc_19 * _loc_15 / _loc_16;
                            break;
                        }
                        default:
                        {
                            break;
                        }
                    }
                    if (_loc_12 < 0 || _loc_12 >= _local8.width || _loc_13 < 0 || _loc_13 >= _local8.height)
                    {
                        _local8.setPixel32(_loc_17, _loc_22, _local8.getPixel32(this.clamp(_loc_12, 0, (_local8.width - 1)), this.clamp(_loc_13, 0, (_local8.height - 1))));
                    }
                    else
                    {
                        _local8.setPixel32(_loc_17, _loc_22, _local8.getPixel32(_loc_12, _loc_13));
                    }
                    _loc_17++;
                }
                _loc_22++;
            }
            return;
        }// end function

        public function Waterswirl(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:int, _local8:Boolean, _local8:Selection, _local8:Point) : void
        {
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            if (_local8)
            {
                _loc_9 = _loc_11.left;
                while (_loc_9 < _loc_11.right)
                {
                    
                    _loc_10 = _loc_11.top;
                    while (_loc_10 < _loc_11.bottom)
                    {
                        
                        _loc_8 = Math.round(_local8 * Math.sin(2 * 3.1415 * _loc_9 / _local8) + _loc_10);
                        if (_loc_8 >= _local8.height)
                        {
                            _loc_8 = _loc_8 - _local8.height;
                        }
                        else if (_loc_8 < 0)
                        {
                            _loc_8 = _loc_8 + _local8.height;
                        }
                        _local8.setPixel32(_loc_9, _loc_8, _local8.getPixel32(_loc_9, _loc_10));
                        _loc_10++;
                    }
                    _loc_9++;
                }
            }
            else
            {
                _loc_10 = _loc_11.top;
                while (_loc_10 < _loc_11.bottom)
                {
                    
                    _loc_9 = _loc_11.left;
                    while (_loc_9 < _loc_11.right)
                    {
                        
                        _loc_8 = Math.round(_local8 * Math.sin(2 * 3.1415 * _loc_10 / _local8) + _loc_9);
                        if (_loc_8 >= _local8.width)
                        {
                            _loc_8 = _loc_8 - _local8.width;
                        }
                        else if (_loc_8 < 0)
                        {
                            _loc_8 = _loc_8 + _local8.width;
                        }
                        _local8.setPixel32(_loc_8, _loc_10, _local8.getPixel32(_loc_9, _loc_10));
                        _loc_9++;
                    }
                    _loc_10++;
                }
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Blur(_local8:BitmapData, _local8:BitmapData, _local8:Selection, _local8:Point) : void
        {
            var _loc_5:int = 0;
            var _loc_6:int = 0;
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:uint = 0;
            var _loc_11:uint = 0;
            var _loc_12:uint = 0;
            var _loc_13:uint = 0;
            var _loc_14:uint = 0;
            var _loc_15:int = 0;
            var _loc_16:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            var _loc_17:* = _loc_16.top;
            while (_loc_17 < _loc_16.bottom)
            {
                
                _loc_12 = _local8.getPixel32((_loc_16.left + 1), _loc_17);
                _loc_11 = _local8.getPixel32(_loc_16.left, _loc_17);
                _loc_15 = _loc_16.left;
                while (_loc_15 < _loc_16.right)
                {
                    
                    _loc_10 = _loc_11;
                    _loc_11 = _loc_12;
                    _loc_13 = _local8.getPixel32(_loc_15, (_loc_17 + 1));
                    _loc_14 = _local8.getPixel32(_loc_15, (_loc_17 - 1));
                    _loc_12 = _local8.getPixel32((_loc_15 + 1), _loc_17);
                    _loc_9 = 0;
                    _loc_5 = 0;
                    _loc_6 = 0;
                    _loc_7 = 0;
                    _loc_8 = 0;
                    if (_loc_10 >>> 24 & 255 > 0)
                    {
                        _loc_5 = _loc_5 + (_loc_10 >>> 24 & 255);
                        _loc_6 = _loc_6 + (_loc_10 >>> 16 & 255);
                        _loc_7 = _loc_7 + (_loc_10 >>> 8 & 255);
                        _loc_8 = _loc_8 + (_loc_10 & 255);
                        _loc_9++;
                    }
                    if (_loc_12 >>> 24 & 255 > 0)
                    {
                        _loc_5 = _loc_5 + (_loc_12 >>> 24 & 255);
                        _loc_6 = _loc_6 + (_loc_12 >>> 16 & 255);
                        _loc_7 = _loc_7 + (_loc_12 >>> 8 & 255);
                        _loc_8 = _loc_8 + (_loc_12 & 255);
                        _loc_9++;
                    }
                    if (_loc_11 >>> 24 & 255 > 0)
                    {
                        _loc_5 = _loc_5 + (_loc_11 >>> 24 & 255);
                        _loc_6 = _loc_6 + (_loc_11 >>> 16 & 255);
                        _loc_7 = _loc_7 + (_loc_11 >>> 8 & 255);
                        _loc_8 = _loc_8 + (_loc_11 & 255);
                        _loc_9++;
                    }
                    if (_loc_13 >>> 24 & 255 > 0)
                    {
                        _loc_5 = _loc_5 + (_loc_13 >>> 24 & 255);
                        _loc_6 = _loc_6 + (_loc_13 >>> 16 & 255);
                        _loc_7 = _loc_7 + (_loc_13 >>> 8 & 255);
                        _loc_8 = _loc_8 + (_loc_13 & 255);
                        _loc_9++;
                    }
                    if (_loc_14 >>> 24 & 255 > 0)
                    {
                        _loc_5 = _loc_5 + (_loc_11 >>> 24 & 255);
                        _loc_6 = _loc_6 + (_loc_11 >>> 16 & 255);
                        _loc_7 = _loc_7 + (_loc_11 >>> 8 & 255);
                        _loc_8 = _loc_8 + (_loc_11 & 255);
                        _loc_9++;
                    }
                    _loc_5 = _loc_5 / 5;
                    _loc_6 = _loc_6 / _loc_9;
                    _loc_7 = _loc_7 / _loc_9;
                    _loc_8 = _loc_8 / _loc_9;
                    _local8.setPixel32(_loc_15, _loc_17, _loc_5 << 24 | _loc_6 << 16 | _loc_7 << 8 | _loc_8);
                    _loc_15++;
                }
                _loc_17++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function BoxBlur(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:Selection, _local8:Point) : void
        {
            var _loc_6:int = 0;
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_12:int = 0;
            var _loc_13:int = 0;
            var _loc_14:int = 0;
            var _loc_15:int = 0;
            var _loc_16:int = 0;
            var _loc_17:int = 0;
            var _loc_18:int = 0;
            var _loc_19:int = 0;
            _loc_18 = _local8.width;
            _loc_19 = _local8.height;
            var _loc_20:* = _loc_18 - 1;
            var _loc_21:* = _loc_19 - 1;
            var _loc_22:* = _local8 * 2 + 1;
            var _loc_23:* = new Vector.<int>(_loc_18 * _loc_19, true);
            var _loc_24:* = new Vector.<int>(_loc_18 * _loc_19, true);
            var _loc_25:* = new Vector.<int>(_loc_18 * _loc_19, true);
            var _loc_26:* = new Vector.<int>(_loc_18 > _loc_19 ? (_loc_18) : (_loc_19), true);
            var _loc_27:* = new Vector.<int>(_loc_18 > _loc_19 ? (_loc_18) : (_loc_19), true);
            var _loc_28:* = new Vector.<int>(256 * _loc_22, true);
            var _loc_29:* = _local8.getVector(_local8.rect);
            _loc_12 = 0;
            while (_loc_12 < 256 * _loc_22)
            {
                
                _loc_28[_loc_12] = _loc_12 / _loc_22;
                _loc_12++;
            }
            _loc_16 = 0;
            _loc_17 = _loc_16;
            _loc_10 = 0;
            while (_loc_10 < _loc_19)
            {
                
                _loc_8 = 0;
                _loc_7 = _loc_8;
                _loc_6 = _loc_7;
                _loc_12 = -_local8;
                while (_loc_12 <= _local8)
                {
                    
                    _loc_11 = _loc_29[_loc_16 + Math.min(_loc_20, Math.max(_loc_12, 0))];
                    _loc_6 = _loc_6 + ((_loc_11 & 16711680) >> 16);
                    _loc_7 = _loc_7 + ((_loc_11 & 65280) >> 8);
                    _loc_8 = _loc_8 + (_loc_11 & 255);
                    _loc_12++;
                }
                _loc_9 = 0;
                while (_loc_9 < _loc_18)
                {
                    
                    _loc_23[_loc_16] = _loc_28[_loc_6];
                    _loc_24[_loc_16] = _loc_28[_loc_7];
                    _loc_25[_loc_16] = _loc_28[_loc_8];
                    if (_loc_10 == 0)
                    {
                        _loc_27[_loc_9] = Math.min(_loc_9 + _local8 + 1, _loc_20);
                        _loc_26[_loc_9] = Math.max(_loc_9 - _local8, 0);
                    }
                    _loc_13 = _loc_29[_loc_17 + _loc_27[_loc_9]];
                    _loc_14 = _loc_29[_loc_17 + _loc_26[_loc_9]];
                    _loc_6 = _loc_6 + ((_loc_13 & 16711680) - (_loc_14 & 16711680) >> 16);
                    _loc_7 = _loc_7 + ((_loc_13 & 65280) - (_loc_14 & 65280) >> 8);
                    _loc_8 = _loc_8 + ((_loc_13 & 255) - (_loc_14 & 255));
                    _loc_16++;
                    _loc_9++;
                }
                _loc_17 = _loc_17 + _loc_18;
                _loc_10++;
            }
            _loc_9 = 0;
            while (_loc_9 < _loc_18)
            {
                
                _loc_8 = 0;
                _loc_7 = _loc_8;
                _loc_6 = _loc_7;
                _loc_15 = (-_local8) * _loc_18;
                _loc_12 = -_local8;
                while (_loc_12 <= _local8)
                {
                    
                    _loc_16 = _loc_15 < 0 ? (0) : (_loc_15 + _loc_9);
                    _loc_6 = _loc_6 + _loc_23[_loc_16];
                    _loc_7 = _loc_7 + _loc_24[_loc_16];
                    _loc_8 = _loc_8 + _loc_25[_loc_16];
                    _loc_15 = _loc_15 + _loc_18;
                    _loc_12++;
                }
                _loc_16 = _loc_9;
                _loc_10 = 0;
                while (_loc_10 < _loc_19)
                {
                    
                    _loc_29[_loc_16] = 4278190080 | _loc_28[_loc_6] << 16 | _loc_28[_loc_7] << 8 | _loc_28[_loc_8];
                    if (_loc_9 == 0)
                    {
                        _loc_27[_loc_10] = Math.min(_loc_10 + _local8 + 1, _loc_21) * _loc_18;
                        _loc_26[_loc_10] = Math.max(_loc_10 - _local8, 0) * _loc_18;
                    }
                    _loc_13 = _loc_9 + _loc_27[_loc_10];
                    _loc_14 = _loc_9 + _loc_26[_loc_10];
                    _loc_6 = _loc_6 + (_loc_23[_loc_13] - _loc_23[_loc_14]);
                    _loc_7 = _loc_7 + (_loc_24[_loc_13] - _loc_24[_loc_14]);
                    _loc_8 = _loc_8 + (_loc_25[_loc_13] - _loc_25[_loc_14]);
                    _loc_16 = _loc_16 + _loc_18;
                    _loc_10++;
                }
                _loc_9++;
            }
            _local8.setVector(_local8.rect, _loc_29);
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Sharpen(_local8:BitmapData, _local8:BitmapData, _local8:Selection, _local8:Point) : void
        {
            var _loc_5:uint = 0;
            var _loc_6:uint = 0;
            var _loc_7:uint = 0;
            var _loc_8:uint = 0;
            var _loc_9:uint = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_12:int = 0;
            var _loc_13:int = 0;
            var _loc_14:int = 0;
            var _loc_15:int = 0;
            var _loc_16:int = 0;
            var _loc_17:int = 0;
            var _loc_18:int = 0;
            var _loc_19:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            if (_loc_19.left == 0)
            {
                var _loc_21:* = _loc_19;
                var _loc_22:* = _loc_19.left + 1;
                _loc_21.left = _loc_22;
            }
            if (_loc_19.top == 0)
            {
                var _loc_21:* = _loc_19;
                var _loc_22:* = _loc_19.top + 1;
                _loc_21.top = _loc_22;
            }
            if (_loc_19.right == _local8.width)
            {
                var _loc_21:* = _loc_19;
                var _loc_22:* = _loc_19.right - 1;
                _loc_21.right = _loc_22;
            }
            if (_loc_19.bottom == _local8.height)
            {
                var _loc_21:* = _loc_19;
                var _loc_22:* = _loc_19.bottom - 1;
                _loc_21.bottom = _loc_22;
            }
            _local8.lock();
            var _loc_20:* = _loc_19.top;
            while (_loc_20 < _loc_19.bottom)
            {
                
                _loc_7 = _local8.getPixel(1, _loc_20);
                _loc_6 = _local8.getPixel(0, _loc_20);
                _loc_18 = _loc_19.left;
                while (_loc_18 < _loc_19.right)
                {
                    
                    _loc_5 = _loc_6;
                    _loc_6 = _loc_7;
                    _loc_8 = _local8.getPixel(_loc_18, (_loc_20 + 1));
                    _loc_9 = _local8.getPixel(_loc_18, (_loc_20 - 1));
                    _loc_7 = _local8.getPixel((_loc_18 + 1), _loc_20);
                    _loc_11 = Math.round(((_loc_5 >>> 16 & 255) + (_loc_7 >>> 16 & 255) + (_loc_6 >>> 16 & 255) + (_loc_8 >>> 16 & 255) + (_loc_9 >>> 16 & 255)) / 5);
                    _loc_12 = Math.round(((_loc_5 >>> 8 & 255) + (_loc_7 >>> 8 & 255) + (_loc_6 >>> 8 & 255) + (_loc_8 >>> 8 & 255) + (_loc_9 >>> 8 & 255)) / 5);
                    _loc_13 = Math.round(((_loc_5 & 255) + (_loc_7 & 255) + (_loc_6 & 255) + (_loc_8 & 255) + (_loc_9 & 255)) / 5);
                    _loc_15 = _loc_6 >>> 16 & 255;
                    _loc_16 = _loc_6 >>> 8 & 255;
                    _loc_17 = _loc_6 & 255;
                    _loc_11 = _loc_15 + (_loc_15 - _loc_11);
                    _loc_12 = _loc_16 + (_loc_16 - _loc_12);
                    _loc_13 = _loc_17 + (_loc_17 - _loc_13);
                    if (_loc_11 > 255)
                    {
                        _loc_11 = 255;
                    }
                    else if (_loc_11 < 0)
                    {
                        _loc_11 = 0;
                    }
                    if (_loc_12 > 255)
                    {
                        _loc_12 = 255;
                    }
                    else if (_loc_12 < 0)
                    {
                        _loc_12 = 0;
                    }
                    if (_loc_13 > 255)
                    {
                        _loc_13 = 255;
                    }
                    else if (_loc_13 < 0)
                    {
                        _loc_13 = 0;
                    }
                    _local8.setPixel(_loc_18, _loc_20, _loc_11 << 16 | _loc_12 << 8 | _loc_13);
                    _loc_18++;
                }
                _loc_20++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function UnsharpMask(_local8:BitmapData, _local8:BitmapData, _local8:Number, _local8:int, _local8:int, _local8:Selection, _local8:Point) : void
        {
            var _loc_8:uint = 0;
            var _loc_9:uint = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_12:int = 0;
            var _loc_13:int = 0;
            var _loc_14:int = 0;
            var _loc_15:int = 0;
            var _loc_16:int = 0;
            var _loc_18:int = 0;
            var _loc_17:* = _local8.clone();
            _local8.clone().applyFilter(_local8.clone(), _loc_17.rect, _loc_17.rect.topLeft, new BlurFilter(_local8, _local8, 10));
            while (_loc_18 < _local8.height)
            {
                
                _loc_16 = 0;
                while (_loc_16 < _local8.width)
                {
                    
                    _loc_8 = _local8.getPixel(_loc_16, _loc_18);
                    _loc_9 = _loc_17.getPixel(_loc_16, _loc_18);
                    _loc_10 = _loc_8 >>> 16 & 255;
                    _loc_11 = _loc_8 >>> 8 & 255;
                    _loc_12 = _loc_8 & 255;
                    _loc_13 = _loc_9 >>> 16 & 255;
                    _loc_14 = _loc_9 >>> 8 & 255;
                    _loc_15 = _loc_9 & 255;
                    if (Math.abs(_loc_10 - _loc_13) >= _local8)
                    {
                        _loc_10 = (_local8 + 1) * (_loc_10 - _loc_13) + _loc_13;
                    }
                    if (Math.abs(_loc_11 - _loc_14) >= _local8)
                    {
                        _loc_11 = (_local8 + 1) * (_loc_11 - _loc_14) + _loc_14;
                    }
                    if (Math.abs(_loc_12 - _loc_15) >= _local8)
                    {
                        _loc_12 = (_local8 + 1) * (_loc_12 - _loc_15) + _loc_15;
                    }
                    if (_loc_10 > 255)
                    {
                        _loc_10 = 255;
                    }
                    else if (_loc_10 < 0)
                    {
                        _loc_10 = 0;
                    }
                    if (_loc_11 > 255)
                    {
                        _loc_11 = 255;
                    }
                    else if (_loc_11 < 0)
                    {
                        _loc_11 = 0;
                    }
                    if (_loc_12 > 255)
                    {
                        _loc_12 = 255;
                    }
                    else if (_loc_12 < 0)
                    {
                        _loc_12 = 0;
                    }
                    _local8.setPixel(_loc_16, _loc_18, _loc_10 << 16 | _loc_11 << 8 | _loc_12);
                    _loc_16++;
                }
                _loc_18++;
            }
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Halftone(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:Number, _local8:Boolean, _local8:Boolean, _local8:uint, _local8:Selection, _local8:Point) : void
        {
            var _loc_10:int = 0;
            var _loc_11:uint = 0;
            var _loc_12:Number = NaN;
            var _loc_13:int = 0;
            var _loc_14:* = new Sprite();
            var _loc_15:* = _local8 / 2;
            var _loc_16:* = _local8 / 256 / 2 * _local8;
            var _loc_17:* = int(_local8 / 2);
            var _loc_18:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            var _loc_19:* = _loc_18.top;
            while (_loc_19 < _loc_18.bottom)
            {
                
                _loc_13 = _loc_18.left;
                while (_loc_13 < _loc_18.right)
                {
                    
                    _loc_11 = _local8.getPixel(_loc_13, _loc_19);
                    if (_local8)
                    {
                        _loc_10 = int(((_loc_11 >> 16) + (_loc_11 >> 8 & 255) + (_loc_11 >> 8 & 255)) / 3);
                    }
                    else
                    {
                        _loc_10 = 255 - int(((_loc_11 >> 16) + (_loc_11 >> 8 & 255) + (_loc_11 >> 8 & 255)) / 3);
                    }
                    _loc_12 = _loc_10 * _loc_16;
                    _loc_14.graphics.beginFill(_local8, 1);
                    _loc_14.graphics.drawCircle(_loc_13, _loc_19, _loc_12);
                    _loc_14.graphics.endFill();
                    _loc_13 = _loc_13 + _loc_17;
                }
                _loc_19 = _loc_19 + _loc_17;
            }
            if (!_local8)
            {
                _local8.fillRect(_local8.rect, 4294967295);
            }
            _local8.draw(_loc_14);
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function ArtPoster(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:Number, _local8:Boolean, _local8:Selection, _local8:Point) : void
        {
            var _loc_8:uint = 0;
            var _loc_9:int = 0;
            var _loc_10:Number = NaN;
            var _loc_11:Number = NaN;
            var _loc_12:Number = NaN;
            var _loc_13:Number = NaN;
            var _loc_14:Number = NaN;
            var _loc_15:Number = NaN;
            var _loc_16:Number = NaN;
            var _loc_17:Number = NaN;
            var _loc_18:Number = NaN;
            var _loc_19:Number = NaN;
            var _loc_20:Number = NaN;
            var _loc_21:int = 0;
            var _loc_22:int = 0;
            var _loc_23:int = 0;
            var _loc_24:int = 0;
            var _loc_25:int = 0;
            var _loc_26:* = Math.round((256 - _local8) / 2);
            var _loc_27:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            var _loc_28:* = _loc_27.top;
            while (_loc_28 < _loc_27.bottom)
            {
                
                _loc_25 = _loc_27.left;
                while (_loc_25 < _loc_27.right)
                {
                    
                    _loc_8 = _local8.getPixel32(_loc_25, _loc_28);
                    _loc_10 = _loc_8 >>> 24 & 255;
                    _loc_11 = _loc_8 >>> 16 & 255;
                    _loc_12 = _loc_8 >>> 8 & 255;
                    _loc_13 = _loc_8 & 255;
                    _loc_9 = int((_loc_11 + _loc_12 + _loc_13) / 3);
                    if (_loc_9 < _loc_26)
                    {
                        _loc_13 = _local8 ? (255) : (0);
                        _loc_12 = _loc_13;
                        _loc_11 = _loc_12;
                    }
                    else if (_loc_9 > 255 - _loc_26)
                    {
                        _loc_13 = _local8 ? (0) : (255);
                        _loc_12 = _loc_13;
                        _loc_11 = _loc_12;
                    }
                    else
                    {
                        _loc_21 = Math.min(_loc_11, _loc_12, _loc_13);
                        _loc_22 = Math.max(_loc_11, _loc_12, _loc_13);
                        _loc_20 = _loc_22 * 100 / 255;
                        _loc_23 = _loc_22 - _loc_21;
                        if (_loc_23)
                        {
                            _loc_19 = 100 * (_loc_23 / _loc_22);
                        }
                        else
                        {
                            _loc_19 = 0;
                        }
                        _loc_19 = (_loc_19 + 50) / 100;
                        _loc_20 = (_loc_20 - 35) / 100;
                        if (_loc_20 == 0)
                        {
                            _loc_11 = 0;
                            _loc_12 = 0;
                            _loc_13 = 0;
                        }
                        else if (_loc_19 == 0)
                        {
                            _loc_13 = _loc_20;
                            _loc_12 = _loc_13;
                            _loc_11 = _loc_12;
                        }
                        else
                        {
                            _loc_18 = _local8 / 60;
                            _loc_17 = _loc_18 - int(_loc_18);
                            _loc_14 = _loc_20 * (1 - _loc_19);
                            _loc_15 = _loc_20 * (1 - _loc_19 * _loc_17);
                            _loc_16 = _loc_20 * (1 - _loc_19 * (1 - _loc_17));
                            switch(int(_loc_18))
                            {
                                case 0:
                                {
                                    _loc_11 = _loc_20;
                                    _loc_12 = _loc_16;
                                    _loc_13 = _loc_14;
                                    break;
                                }
                                case 1:
                                {
                                    _loc_11 = _loc_15;
                                    _loc_12 = _loc_20;
                                    _loc_13 = _loc_14;
                                    break;
                                }
                                case 2:
                                {
                                    _loc_11 = _loc_14;
                                    _loc_12 = _loc_20;
                                    _loc_13 = _loc_16;
                                    break;
                                }
                                case 3:
                                {
                                    _loc_11 = _loc_14;
                                    _loc_12 = _loc_15;
                                    _loc_13 = _loc_20;
                                    break;
                                }
                                case 4:
                                {
                                    _loc_11 = _loc_16;
                                    _loc_12 = _loc_14;
                                    _loc_13 = _loc_20;
                                    break;
                                }
                                case 5:
                                {
                                    _loc_11 = _loc_20;
                                    _loc_12 = _loc_14;
                                    _loc_13 = _loc_15;
                                    break;
                                }
                                case 6:
                                {
                                    _loc_11 = _loc_20;
                                    _loc_12 = _loc_16;
                                    _loc_13 = _loc_14;
                                    break;
                                }
                                default:
                                {
                                    break;
                                }
                            }
                        }
                        _loc_11 = _loc_11 * 255;
                        _loc_12 = _loc_12 * 255;
                        _loc_13 = _loc_13 * 255;
                        if (_loc_11 > 255)
                        {
                            _loc_11 = 255;
                        }
                        else if (_loc_11 < 0)
                        {
                            _loc_11 = 0;
                        }
                        if (_loc_12 > 255)
                        {
                            _loc_12 = 255;
                        }
                        else if (_loc_12 < 0)
                        {
                            _loc_12 = 0;
                        }
                        if (_loc_13 > 255)
                        {
                            _loc_13 = 255;
                        }
                        else if (_loc_13 < 0)
                        {
                            _loc_13 = 0;
                        }
                    }
                    _local8.setPixel32(_loc_25, _loc_28, _loc_10 << 24 | _loc_11 << 16 | _loc_12 << 8 | _loc_13);
                    _loc_25++;
                }
                _loc_28++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Pixelate(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:Selection, _local8:Point) : void
        {
            var _loc_6:int = 0;
            var _loc_7:uint = 0;
            var _loc_8:Number = NaN;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_12:* = int(_local8 / 2);
            var _loc_13:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            var _loc_14:* = _loc_12;
            while (_loc_14 < _local8.height)
            {
                
                _loc_9 = _loc_12;
                while (_loc_9 < _local8.width)
                {
                    
                    _loc_7 = _local8.getPixel(_loc_9, _loc_14);
                    _loc_10 = -_loc_12;
                    while (_loc_10 < _local8 - _loc_12)
                    {
                        
                        _loc_11 = -_loc_12;
                        while (_loc_11 < _local8 - _loc_12)
                        {
                            
                            if (_loc_13.contains(_loc_9 + _loc_11, _loc_14 + _loc_10))
                            {
                                _local8.setPixel(_loc_9 + _loc_11, _loc_14 + _loc_10, _loc_7);
                            }
                            _loc_11++;
                        }
                        _loc_10++;
                    }
                    _loc_9 = _loc_9 + _local8;
                }
                _loc_14 = _loc_14 + _local8;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Kaleidoscope(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:int, _local8:int, _local8:Selection, _local8:Point) : void
        {
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_12:int = 0;
            var _loc_13:Boolean = false;
            var _loc_14:Boolean = false;
            var _loc_15:int = 0;
            var _loc_22:int = 0;
            _local8.lock();
            var _loc_16:* = _local8 / 75 * ((_local8.width + _local8.height) / 2);
            _local8 = _local8 / 75 * ((_local8.width + _local8.height) / 2);
            var _loc_17:* = _loc_16 * _local8;
            var _loc_18:* = Math.round(_local8 / 100 * _local8.width);
            var _loc_19:* = Math.round(_local8 / 100 * _local8.height);
            var _loc_20:* = _local8.height;
            var _loc_21:* = _local8.width;
            while (_loc_22 < _loc_20)
            {
                
                _loc_12 = _loc_22 - _loc_19;
                _loc_15 = 0;
                while (_loc_15 < _loc_21)
                {
                    
                    _loc_11 = _loc_15 - _loc_18;
                    _loc_8 = (_loc_15 - _loc_18) * _loc_11 + _loc_12 * _loc_12;
                    if (_loc_8 != 0)
                    {
                        _loc_9 = _loc_18 + _loc_17 * _loc_11 / _loc_8;
                        _loc_10 = _loc_19 + _loc_17 * _loc_12 / _loc_8;
                    }
                    else
                    {
                        _loc_9 = _loc_18;
                        _loc_10 = _loc_19;
                    }
                    _loc_13 = false;
                    while (_loc_9 < 0)
                    {
                        
                        _loc_9 = _loc_9 + _loc_21;
                    }
                    while (_loc_9 >= _loc_21)
                    {
                        
                        _loc_9 = _loc_9 - _loc_21;
                    }
                    _loc_14 = false;
                    while (_loc_10 < 0)
                    {
                        
                        _loc_10 = _loc_10 + _loc_20;
                    }
                    while (_loc_10 >= _loc_20)
                    {
                        
                        _loc_10 = _loc_10 - _loc_20;
                    }
                    if (_loc_13)
                    {
                        _loc_9 = (_loc_21 - 1) - _loc_9;
                    }
                    if (_loc_14)
                    {
                        _loc_10 = (_loc_20 - 1) - _loc_10;
                    }
                    _local8.setPixel32(_loc_15, _loc_22, _local8.getPixel32(_loc_9, _loc_10));
                    _loc_15++;
                }
                _loc_22++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

        public function Pastel(_local8:BitmapData, _local8:BitmapData, _local8:int, _local8:Boolean, _local8:Selection, _local8:Point) : void
        {
            var _loc_7:uint = 0;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_12:int = 0;
            var _loc_13:int = 0;
            var _loc_14:* = Misc.GetAffectedRect(_local8, _local8, _local8);
            _local8.lock();
            var _loc_15:* = _loc_14.top;
            while (_loc_15 < _loc_14.bottom)
            {
                
                _loc_13 = _loc_14.left;
                while (_loc_13 < _loc_14.right)
                {
                    
                    _loc_7 = _local8.getPixel(_loc_13, _loc_15);
                    _loc_8 = _loc_7 >>> 16 & 255;
                    _loc_9 = _loc_7 >>> 8 & 255;
                    _loc_10 = _loc_7 & 255;
                    _loc_12 = _loc_15 - _local8;
                    while (_loc_12++ < _loc_15 + _local8)
                    {
                        
                        _loc_11 = _loc_13 - _local8;
                        while (_loc_11++ < _loc_13 + _local8)
                        {
                            
                            _loc_7 = _local8.getPixel(_loc_11, _loc_12);
                            if (_local8)
                            {
                                _loc_8 = Math.min(_loc_8, _loc_7 >> 16 & 255);
                                _loc_9 = Math.min(_loc_9, _loc_7 >> 8 & 255);
                                _loc_10 = Math.min(_loc_10, _loc_7 & 255);
                                continue;
                            }
                            _loc_8 = Math.max(_loc_8, _loc_7 >> 16 & 255);
                            _loc_9 = Math.max(_loc_9, _loc_7 >> 8 & 255);
                            _loc_10 = Math.max(_loc_10, _loc_7 & 255);
                        }
                    }
                    _local8.setPixel(_loc_13, _loc_15, _loc_8 << 16 | _loc_9 << 8 | _loc_10);
                    _loc_13++;
                }
                _loc_15++;
            }
            _local8.unlock();
            Misc.ApplySelection(_local8, _local8, _local8, _local8);
            return;
        }// end function

    }
}
